// 放置在CardMap中，暴露给外面使用的接口
// import Map from 'ol/Map'

export default {
  data () {
    return {}
  },
  watch: {
    // watch
  },
  mounted () {
  },
  methods: {
    /**
     * @description 清空热力数据
     * @param  null
     * @return null
     */
    clearHeatGridData () {
      // 清空网格热力数据
      this.$refs.iHeatmap.clearHeatGridData()
    },
    destroyHeatmapLayer () {
      // 销毁热力层-数据，网格，图层
      this.$refs.iHeatmap.destroyHeatmapLayer()
    },
    /**
     * @description 设置图标缩放标志位接口 POI（poiExt文件中）
     * @param  {boolean} isZoom // true可以缩放，false不可缩放
     * @return null
     */
    setIconZoomIO (isZoom) {
      this.$refs.iPoi.setIconZoom(isZoom)
    },
    /**
     * @description 获取图标缩放标志位接口 POI
     * @param  null
     * @return POI图标缩放标志位
     */
    getIconZoomIO () {
      return this.$refs.iPoi.getIconZoom()
    },
    zoomIconIO (oFeature) {
      return this.$refs.iPoi.zoomIcon(oFeature)
    },
    /**
     * @description 根据给定的featureID缩放图标接口
     * @param {String} sID
     * @param {boolean} bShowPop 是否显示气泡
     * @return POI图标缩放标志位
     */
    zoomIconByIdIO (sID, bShowPop = 'true') {
      const sZoom = this.$refs.iPoi.zoomIconByID(sID)
      if (sZoom === 'zoomin' && bShowPop) { // 图标放大且 显示气泡标志位true
        this.showBubbleByID(sID)
      } else if (sZoom === 'zoomout') { // 缩小
        const popID = 'pop' + sID
        this.closeBubbleById(popID) // 此方法在mapBubble.js
      }
    },
    /**
     * @description 清除所有变大图标
     * @param  {Object} oFeature 图标变大的featrue对象
     * @return null
     */
    clearAllZoominIO () {
      return this.$refs.iPoi.clearAllZoomin()
    },
    /**
     * @description 获得所有变大数据信息
     * @param
     * @return 变大图标的featrue信息[id: {气泡信息}，id:{气泡信息}]
     */
    getAllBigInfosIO () {
      return this.$refs.iPoi.getAllBigInfos()
    },
    /**
     * @description 区域选择
     * @param {String} aCoordArr 区域坐标数组
     * @param {float} radius 如果区域是圆，此参数为圆半径；如果区域是多边形，此参数为空或0
     * @param {String} sRCS 区域范围（参数1）使用的参考坐标系（款选获得的数据所在空间坐标系）
     * @return POI图标缩放标志位
     */
    regionSelectIO (aCoordArr, radius = null, sRCS = 'EPSG:4326') {
      this.$refs.iPoi.clearAllZoomin() // 首先清除所有已经选中的feature（清除所有大图标）
      const oView = this.imap.getView()
      const sMapRCS = oView.getProjection().getCode() // 当前地图使用大参考坐标系--从地图获取到的feature的坐标系（数据的空间坐标系）
      let regArr = null
      if (sRCS !== 'EPSG:3857') { // 区域范围参考坐标系 不是 EPSG:3857
        regArr = this.coordArrTransform(aCoordArr, sRCS, 'EPSG:3857') // 转换范围所有点的坐标系
      } else {
        regArr = aCoordArr
      }
      console.log(regArr)
      // 根据名称获取指定的POI图层
      const oMapLayer = this.getLayerByName('poiLayer', this.imap)
      if (!oMapLayer) {
        return
      }
      const oPoiSource = oMapLayer.getSource()
      const oFeatures = oPoiSource.getFeatures() // 获取所有的POI层的feature
      if (radius) { // 如果有边境范围，说明时圆形区域选择
        // console.log(oFeatures[0].getGeometry().getCoordinates(), sMapRCS)
        // const poiFeatureArr = oMapLayer oFeatures.getGeometry().getCoordinates()
        const numFeature = oFeatures.length
        for (let i = 0; i < numFeature; i++) {
          const poi = oFeatures[i]
          const geometry = poi.getGeometry()
          const iType = geometry.getType().toLowerCase()
          if (iType === 'point') {
            const coord = geometry.getCoordinates()
            // 判断poi是否在圆区域内(point, circle, r, sRCS = 'EPSG:4326')
            console.log(coord, regArr[0], radius, sMapRCS)
            const bInRegion = this.pointInsideCircle(coord, regArr[0], radius, sMapRCS)
            if (bInRegion) {
              // 测试poi在范围内，需要将id添加到指定数组（关联？）
              this.zoomIconIO(poi)
            }
          }
        }
      } else { // 没有半径说明时多边形选择
        const numFeature = oFeatures.length
        for (let i = 0; i < numFeature; i++) {
          const poi = oFeatures[i]
          const geometry = poi.getGeometry()
          const iType = geometry.getType().toLowerCase()
          if (iType === 'point') {
            const coord = geometry.getCoordinates()
            // 判断poi是否在多边形中
            console.log(coord, regArr, sMapRCS)
            const bInRegion = this.insidePolygon(coord, regArr, sMapRCS)
            if (bInRegion) {
              // 测试poi在范围内，需要将id添加到指定数组（关联？）
              this.zoomIconIO(poi)
            }
          }
        }
      }
    },
    // debug function
    testRegSel (sDrawType, isPoly = true) {
      sDrawType = sDrawType || 'Circle'
      this.startDrawByType(null, false)
      this.drawTypeChange(sDrawType)
      setTimeout(() => {
        const aCoordArr = this.getFeatureLonLat()
        console.log(aCoordArr)
        if (!aCoordArr) return // 每次行会报错
        let aCoordx
        let r = 0
        console.log(sDrawType, isPoly)
        if (sDrawType === 'Circle' && !isPoly) {
          aCoordx = [aCoordArr.cp]
          r = aCoordArr.radius
        } else if (sDrawType === 'Circle' && isPoly) {
          aCoordx = aCoordArr.aCoord[0]
        } else {
          aCoordx = aCoordArr
        }
        console.log(aCoordx, r, 'EPSG:4326')
        this.regionSelectIO(aCoordx, r, 'EPSG:4326')
      }, 5000)
    },
    // 测试中心点方法:测试mapBase.js文件中的getCoordListCP
    getcoordArrCP (sDrawType = 'Circle') {
      this.startDrawByType(null, false)
      this.drawTypeChange(sDrawType)
      setTimeout(() => {
        const aCoordArr = this.getFeatureLonLat()
        if (!aCoordArr) return
        const aCoordx = aCoordArr.aCoord[0]
        const cp = this.getCoordListCP(aCoordx)
        console.log(cp)
        // this.drawCoordByLonLat(cp)
      }, 5000)
    },
    // --------标绘协同------------
    getPlotFileID () {
      return this.$refs.iPlotting.getPlotFileID()
    },
    setPlotFileID (sPlotFileID) {
      this.$refs.iPlotting.setPlotFileID(sPlotFileID)
    },
    getPlotBaseInfo () {
      return this.$refs.iPlotting.getPlotBaseInfo()
    },
    // -- 保存标绘数据到数据库
    savePlotData2DB () {
      this.$refs.iPlotting.savePlotData2DB()
    },
    // -- 保存标绘文件信息到数据库
    savePlotFile2DB (fileInfo) {
      console.log(fileInfo)
      const newInfo = {
        plot_id: this.getPlotFileID(),
        boundary: fileInfo.边框, // 可能不是这个参数
        has_rsc: fileInfo.直角坐标系,
        // 缺少直角坐标系的长度和单位设置==后续变更接口和数据库及代码
        // plot_text: JSON.stringify(fileInfo.文字),
        // legend: JSON.stringify(fileInfo.图例),
        // compass: JSON.stringify(fileInfo.指南针),
        // scale: JSON.stringify(fileInfo.比例尺)
        plot_text: fileInfo.文字,
        legend: fileInfo.图例,
        compass: fileInfo.指南针,
        scale: fileInfo.比例尺
      }
      console.log(newInfo)
      this.$refs.iPlotting.updatePlotFile2DB(newInfo)
    },
    // -- 加载标绘文件数据（只有数据-内部方式）；参数
    loadPlotData (isAllData = false) {
      this.$refs.iPlotting.loadPlotData(isAllData)
    },
    // -- 协同标绘开关
    syncPlotSwitch (bOnOff) {
      this.$refs.iPlotting.syncPlotSwitch(bOnOff)
    },
    // -- 新补充方法 --
    /**  获取当前视图中心点
     * 获取当前窗口中的中心点和地图层级
    */
    getViewCenter () {
      const mapView = this.imap.getView()
      const cp = mapView.getCenter()
      let lonlat = cp
      if (this.conf.RCS !== 'EPSG:4326') {
        lonlat = this.Coordtransform(cp, this.conf.RCS, 'EPSG:4326')
      }
      // console.log(lonlat)
      const zomLevel = mapView.getZoom()
      console.log({ cp: lonlat, level: zomLevel })
      return { cp: lonlat, level: zomLevel }
    },
    // -- 显示隐藏指定地图层 -
    /**
     * 根据指定的图层名称，设置是否显示此层
     * @param {string} layerName 地图层名称
     * @param {Boolean} bDisplay 是否显示图层
     */
    // 参数：要操作的地图层， 参数2：是否显示
    setLayerVisibleByName (layerName, bDisplay) {
      const oMapLayer = this.getLayerByName(layerName, this.imap) // 获取最有一个名称符合条件的图层
      const bVisible = oMapLayer.getVisible()
      if (oMapLayer) {
        if (bDisplay) { // 如果设置为展示图层
          if (!bVisible) oMapLayer.setVisible(true)
        } else { // 关闭指定地图图层
          if (bVisible) oMapLayer.setVisible(false)
        }
      }
    },
    // 显示隐藏边界成
    setGeoLayerVisible (bVisible) {
      if (this.geoMapLayer) {
        const bCurrVisible = this.geoMapLayer.getVisible()
        if (bVisible) { // 如果设置为展示图层
          if (!bCurrVisible) this.geoMapLayer.setVisible(true)
        } else { // 关闭指定地图图层
          if (bCurrVisible) this.geoMapLayer.setVisible(false)
        }
      }
    },
    // -- 根据图层名称删除数据
    /**
     * 删除指定图层上的绘制数据
     * @param {string} sLayerName 地图层名称
     * @param {object} oMap 地图对象
     */
    clearLayerByName (sLayerName, oMap = this.imap) {
      const oMapLayer = this.getLayerByName(sLayerName, oMap)
      if (oMapLayer) {
        const oSource = oMapLayer.getSource()
        oSource.clear()
      }
    },
    // -- 清除poi层数据
    clearPOIData () {
      this.$refs.iPoi.clearPOIData()
    },
    // -- 清除plot层数据
    clearPlotData () {
      this.$refs.iPlotting.clearData()
    },
    // -- 获取边界隐藏级别
    getHideLevel () {
      return this.hideLevel
    },
    // -- 获取边界隐藏级别
    setHideLevel (fHideLevel) {
      this.hideLevel = fHideLevel
    },
    /** 触发事件
     * @param {string} emitName 触发事件名称
     * @param {object} emitData 事件携带数据
     * 在标绘界面中-- 删除军标，军标绘制完成处添加了（plotting/plottinglayer.vue） plotupdata事件   2604
     */
    emitFun (emitName, emitData) {
      this.$emit(emitName, emitData)
    },

    /**
     * @description 获取feature的中心点
     * @param {sID} 要获取中心点的feature ID
     */
    getFeatureCenterByID (sID, sLayerName = 'drawLayer', oMap = this.imap) {
      if (!sID) return // 不指定id不做处理
      // 获取层信息
      const oLayer = this.getLayerByName(sLayerName, oMap)
      if (!oLayer) return
      // 获取id对应的feature
      const oSource = oLayer.getSource()
      // const aFeatures = oSource.getFeatures()
      // const numFeature = aFeatures.length
      const oFeature = oSource.getFeatureById(sID)
      // console.log(aFeatures[0].getGeometry().getType())
      // for (let i = 0; i < numFeature; i++) {
      //   const xID = aFeatures[i].getId()
      //   console.log(sID, xID)
      //   if (sID !== xID) {
      //     oFeature = aFeatures[i]
      //   }
      // }
      if (!oFeature) return
      const oGeometry = oFeature.getGeometry()
      const sType = oGeometry.getType()
      let featureCP = null
      // console.log(sType)
      switch (sType) {
        case 'Polygon':
          // 获取多边形的中心
          featureCP = oGeometry.getInteriorPoint().getCoordinates()
          break
        case 'Circle':
          // 获得圆心点
          featureCP = oGeometry.getCenter()
          break
        case 'LineString':
          // 通过计算获取线的中心位置
          featureCP = oGeometry.getCoordinateAt(0.5)
          break
        case 'Point':
          // 直接返回点的坐标点
          featureCP = oGeometry.getCoordinates()
          break
      //   default:
      //     与 case 1 和 case 2 不同时执行的代码Point
      }
      // 返回数据必须是EPSG:4326
      if (this.conf.RCS !== 'EPSG:4326') {
        featureCP = this.Coordtransform(featureCP, this.conf.RCS, 'EPSG:4326')
      }
      console.log(featureCP)
      return featureCP
    },
    // 测试--完成后可以删除
    getFeatureCenterByIDTest () {
      const txtID = document.getElementById('fid').value
      console.log(txtID)
      const cp = this.getFeatureCenterByID(txtID)
      this.createLabel(cp, '测试123abc', txtID)
      this.getObjDataExt()
      setTimeout(() => {
        this.updateLabel(txtID, '更新文字信息！')
      }, 2000)
      setTimeout(() => {
        this.delLabelByID(txtID)
      }, 5000)
    },
    // 修改绘画层级adjust Map Layer Level // this.drawLayer.setZIndex(80) drawLayer
    changeMapLayerLevel (sLayerName, zindex, oMap = this.imap) {
      const oMapLayer = this.getLayerByName(sLayerName, oMap) // 方法在mapBase中定义
      if (oMapLayer) {
        oMapLayer.setZIndex(zindex)
      }
    }
  }
}
